```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>分布式事务全解析 | 技术小馆</title>
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', 'Noto Serif SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.8;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #6e8efb 0%, #a777e3 100%);
        }
        .card-hover {
            transition: all 0.3s ease;
        }
        .card-hover:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
        .highlight {
            position: relative;
        }
        .highlight::after {
            content: '';
            position: absolute;
            left: 0;
            bottom: 0;
            width: 100%;
            height: 30%;
            background-color: rgba(110, 142, 251, 0.2);
            z-index: -1;
            transition: all 0.3s ease;
        }
        .highlight:hover::after {
            height: 50%;
        }
        .drop-cap:first-letter {
            float: left;
            font-size: 3.5em;
            line-height: 0.8;
            margin: 0.1em 0.1em 0.1em 0;
            color: #6e8efb;
            font-weight: 700;
        }
    </style>
</head>
<body class="bg-gray-50">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 md:py-32 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row items-center">
                <div class="md:w-1/2 mb-10 md:mb-0">
                    <h1 class="text-4xl md:text-5xl font-bold mb-6 leading-tight">分布式事务全解析</h1>
                    <p class="text-xl mb-8 opacity-90">探索现代分布式系统中数据一致性与高可用的平衡之道</p>
                    <div class="flex space-x-4">
                        <a href="#what-is" class="bg-white text-purple-600 px-6 py-3 rounded-lg font-medium hover:bg-opacity-90 transition">开始探索</a>
                        <a href="#solutions" class="border-2 border-white text-white px-6 py-3 rounded-lg font-medium hover:bg-white hover:bg-opacity-10 transition">解决方案</a>
                    </div>
                </div>
                <div class="md:w-1/2">
                    <div class="mermaid bg-white bg-opacity-10 p-6 rounded-xl">
                        graph TD
                            A[事务] --> B[ACID特性]
                            A --> C[本地事务]
                            A --> D[分布式事务]
                            D --> E[CAP理论]
                            D --> F[BASE理论]
                            D --> G[解决方案]
                            G --> H[2PC/3PC]
                            G --> I[TCC]
                    </div>
                </div>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-6xl px-4 py-16">
        <!-- What is Transaction -->
        <section id="what-is" class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-database mr-4 text-blue-500"></i>
                <span class="highlight">什么是事务</span>
            </h2>
            <div class="bg-white rounded-xl shadow-md p-8 card-hover">
                <p class="drop-cap text-lg text-gray-700 leading-relaxed">
                    事务是应用程序中一系列严密的操作，所有操作必须成功完成，否则在每个操作中所作的所有更改都会被撤消。也就是事务具有原子性，一个事务中的一系列的操作要么全部成功，要么一个都不做。
                </p>
            </div>
        </section>

        <!-- ACID -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-shield-alt mr-4 text-green-500"></i>
                <span class="highlight">事务特性(ACID)</span>
            </h2>
            <div class="grid md:grid-cols-2 gap-6">
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <h3 class="text-xl font-bold mb-4 text-blue-600 flex items-center">
                        <i class="fas fa-atom mr-2"></i>
                        原子性（A）
                    </h3>
                    <p class="text-gray-700">所谓的原子性就是说，在整个事务中的所有操作，要么全部完成，要么全部不做，没有中间状态。对于事务在执行中发生错误，所有的操作都会被回滚，整个事务就像从没被执行过一样。</p>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <h3 class="text-xl font-bold mb-4 text-blue-600 flex items-center">
                        <i class="fas fa-link mr-2"></i>
                        一致性（C）
                    </h3>
                    <p class="text-gray-700">事务的执行必须保证系统的一致性，就拿转账为例，A有500元，B有300元，如果在一个事务里A成功转给B50元，那么不管并发多少，不管发生什么，只要事务执行成功了，那么最后A账户一定是450元，B账户一定是350元。</p>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <h3 class="text-xl font-bold mb-4 text-blue-600 flex items-center">
                        <i class="fas fa-user-shield mr-2"></i>
                        隔离性（I）
                    </h3>
                    <p class="text-gray-700">所谓的隔离性就是说，事务与事务之间不会互相影响，一个事务的中间状态不会被其他事务感知。</p>
                </div>
                <div class="bg-white rounded-xl shadow-md p-6 card-hover">
                    <h3 class="text-xl font-bold mb-4 text-blue-600 flex items-center">
                        <i class="fas fa-lock mr-2"></i>
                        持久性（D）
                    </h3>
                    <p class="text-gray-700">所谓的持久性，就是说一单事务完成了，那么事务对数据所做的变更就完全保存在了数据库中，即使发生停电，系统宕机也是如此。</p>
                </div>
            </div>
        </section>

        <!-- Local vs Distributed -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-code-branch mr-4 text-purple-500"></i>
                <span class="highlight">本地事务 vs 分布式事务</span>
            </h2>
            <div class="grid md:grid-cols-2 gap-8">
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-4 text-purple-600">单体架构</h3>
                        <p class="text-gray-700 mb-4">在传统单体应用中，事务通常在一个数据库内完成，由数据库本身提供ACID保证。</p>
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651156867728-9592fd52-a096-4987-a544-2ad4b87cd8f4.png" alt="单体架构" class="w-full rounded-lg">
                    </div>
                </div>
                <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                    <div class="p-6">
                        <h3 class="text-xl font-bold mb-4 text-purple-600">微服务架构</h3>
                        <p class="text-gray-700 mb-4">在微服务架构中，业务被拆分到不同的服务，每个服务有自己的数据库，传统事务机制失效。</p>
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651156877846-a83050c2-04c1-4653-a7c4-771a3270e8ea.png" alt="微服务架构" class="w-full rounded-lg">
                    </div>
                </div>
            </div>
        </section>

        <!-- Distributed Transaction -->
        <section class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-network-wired mr-4 text-orange-500"></i>
                <span class="highlight">什么是分布式事务</span>
            </h2>
            <div class="bg-white rounded-xl shadow-md p-8 card-hover">
                <p class="text-lg text-gray-700 leading-relaxed mb-6">
                    在微服务的实现架构系统之中，由于会将不同的业务拆分到不同的微服务实例之中，这样就会彻底的丧失传统数据库事务的支持，这样在进行数据更新时，每一个微服务都仅仅只会与当前关联的数据库实现事务处理，不同的微服务之间没有事务上的联系，一旦出现了错误的数据就可能会出现违反ACID原则的操作，从而使得整个的业务数据出现混乱，导致业务处理出现问题。
                </p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708757674589-570920a3-34b8-4a25-b9f2-11065b36ff46.png" alt="分布式事务" class="w-full rounded-lg mb-6">
                <p class="text-lg text-gray-700 leading-relaxed">
                    简单的说，就是一次大的操作由不同的小操作组成，这些小的操作分布在不同的服务器上，且属于不同的应用，分布式事务需要保证这些小操作要么全部成功，要么全部失败。本质上来说，分布式事务就是为了保证不同数据库的数据一致性。
                </p>
            </div>
        </section>

        <!-- Distributed Theory -->
        <section id="theory" class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-brain mr-4 text-indigo-500"></i>
                <span class="highlight">分布式理论</span>
            </h2>

            <!-- CAP -->
            <div class="mb-16 bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-indigo-600 flex items-center">
                        <i class="fas fa-chess-board mr-3"></i>
                        CAP定律
                    </h3>
                    <p class="text-gray-700 mb-6">CAP 定理，也称为 Brewer's 定理，是分布式系统中的一个基本原理，它指出在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）这三个特性不可能同时满足。</p>
                    <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651156932222-0a25cc68-a137-4967-aa34-2ebb35546a7b.png" alt="CAP理论" class="w-full md:w-2/3 mx-auto rounded-lg mb-6">
                    <div class="grid md:grid-cols-3 gap-6">
                        <div class="bg-indigo-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-indigo-700">一致性（Consistency）</h4>
                            <p class="text-gray-700">所有节点在同一时间具有相同的数据视图。</p>
                        </div>
                        <div class="bg-indigo-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-indigo-700">可用性（Availability）</h4>
                            <p class="text-gray-700">系统保证每个请求都能得到响应，不管请求成功或失败。</p>
                        </div>
                        <div class="bg-indigo-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-indigo-700">分区容错性（Partition tolerance）</h4>
                            <p class="text-gray-700">系统能够容忍网络分区导致部分节点失去联系的情况。</p>
                        </div>
                    </div>
                    <div class="mt-8 bg-yellow-50 border-l-4 border-yellow-400 p-4">
                        <p class="text-yellow-700"><strong>注意：</strong>CAP中的一致性和可用性强调都是强一致性和强可用。强一致性：不管在任何时间段查询任何节点数据都必须一致。强可用：不管在任何时候访问都要有对应的结果响应。</p>
                    </div>
                </div>
            </div>

            <!-- BASE -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-indigo-600 flex items-center">
                        <i class="fas fa-chess-knight mr-3"></i>
                        BASE理论
                    </h3>
                    <p class="text-gray-700 mb-6">BASE 理论是与 ACID 理论相对立的一个理论，主要用于分布式系统的设计和应用。它的名称是基于以下三个概念的缩写：</p>
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708758211577-f3b9d61e-a189-4ef2-bc54-1e6a010759cc.png" alt="BASE理论" class="w-full md:w-2/3 mx-auto rounded-lg mb-6">
                    <div class="grid md:grid-cols-3 gap-6">
                        <div class="bg-blue-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-blue-700">基本可用（Basically Available）</h4>
                            <p class="text-gray-700">系统保证在出现故障时仍然保持基本的可用性，即系统尽最大努力保证服务的可用性，而不是严格保证100%的可用性。</p>
                        </div>
                        <div class="bg-blue-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-blue-700">软状态（Soft state）</h4>
                            <p class="text-gray-700">系统中的数据并不要求实时一致，即允许在一段时间内数据是不一致的，这需要通过后续的同步机制来达成一致性。</p>
                        </div>
                        <div class="bg-blue-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-blue-700">最终一致性（Eventually consistent）</h4>
                            <p class="text-gray-700">系统保证在一段时间内，所有的数据副本最终达到一致的状态。在分布式环境中，数据的同步是一个异步的过程，因此在某个时刻数据可能会存在不一致的状态，但经过一段时间后，系统最终会达到一致状态。</p>
                        </div>
                    </div>
                    <div class="mt-8 bg-blue-50 border-l-4 border-blue-400 p-4">
                        <p class="text-blue-700">基于 BASE 理论设计的分布式系统可以更好地适应大规模、高并发、分布式的特点，强调的是可用性和性能，而不是严格的一致性要求。</p>
                    </div>
                </div>
            </div>
        </section>

        <!-- Solutions -->
        <section id="solutions" class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-cogs mr-4 text-red-500"></i>
                <span class="highlight">分布式解决方案</span>
            </h2>
            <div class="bg-white rounded-xl shadow-md p-8 mb-10 card-hover">
                <p class="text-lg text-gray-700 leading-relaxed">
                    总体来说，分布式事务解决方案可以分为<strong class="text-red-600">强一致性</strong>分布式事务解决方案和<strong class="text-red-600">最终一致性</strong>分布式事务解決方案。
                </p>
                <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708758376582-c37ffed5-8343-4b33-a23f-377ae9e514c0.png" alt="分布式事务解决方案" class="w-full rounded-lg mt-6">
            </div>

            <!-- Strong Consistency -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-bolt mr-3"></i>
                        强一致性事务
                    </h3>
                    <p class="text-gray-700 mb-6">在分布式事务领域，最早采用的是符合 CAP 理论的强一致性事务方案来解决分布式事务问题强一致性分布式事务要求在任意时刻查询参与全局事务的各节点的数据都是一致的。<strong>常见的解决方案有2PC,3PC</strong>。</p>
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708758491853-773c5716-dc6e-4bd0-9b9f-5003ba67f285.png" alt="强一致性事务" class="w-full md:w-2/3 mx-auto rounded-lg mb-6">
                    
                    <div class="grid md:grid-cols-2 gap-6 mt-8">
                        <div>
                            <h4 class="font-bold text-lg mb-3 text-gray-800 flex items-center">
                                <i class="fas fa-check-circle text-green-500 mr-2"></i>
                                适用场景
                            </h4>
                            <p class="text-gray-700">在分布式事务解决方案中，强一致性事务要求应用程序在任何时间，读取任意节点上的数据都是最新写的。强一致性事务主要用于对数据一致性要求比较高，在任意时刻都要查询到最新写人数据的场景，例如跨行转账业务中，张三向李四转账100元，则张三账户減少100李四账户增加 100元，这两个操作要么都执行成功，要么都执行失败。不存在一个成功，另一个失败的情况。</p>
                        </div>
                        <div>
                            <h4 class="font-bold text-lg mb-3 text-gray-800 flex items-center">
                                <i class="fas fa-balance-scale text-blue-500 mr-2"></i>
                                优缺点
                            </h4>
                            <div class="mb-4">
                                <h5 class="font-bold text-green-600 mb-1">优点：</h5>
                                <ul class="list-disc pl-5 text-gray-700">
                                    <li class="mb-1">数据一致性比较高</li>
                                    <li>在任意时刻都能够查询到最新写人的数据</li>
                                </ul>
                            </div>
                            <div>
                                <h5 class="font-bold text-red-600 mb-1">缺点：</h5>
                                <ul class="list-disc pl-5 text-gray-700">
                                    <li class="mb-1">存在性能问题，在分布式事务未完全提交和回滚之前，应用程序不会查询到最新的数据</li>
                                    <li class="mb-1">实现复杂</li>
                                    <li class="mb-1">牺牲了可用性</li>
                                    <li>不适合高并发场景</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- Eventually Consistency -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-hourglass-half mr-3"></i>
                        最终一致性事务
                    </h3>
                    <p class="text-gray-700 mb-6">最终一致性分布式事务解决方案主要用于不要求结果数据时刻保特一致，允许存在中间状态，但经过一段时间后各个节点的数据能够达到一致状态的场景。<strong>常用的解决方案有TCC，可靠消息，最大努力通知</strong>。</p>
                    <img src="https://cdn.nlark.com/yuque/0/2024/png/21449790/1708758590132-e4897e24-100b-470c-9e76-d376b61417e2.png" alt="最终一致性事务" class="w-full md:w-2/3 mx-auto rounded-lg mb-6">
                    
                    <div class="grid md:grid-cols-2 gap-6 mt-8">
                        <div>
                            <h4 class="font-bold text-lg mb-3 text-gray-800 flex items-center">
                                <i class="fas fa-check-circle text-green-500 mr-2"></i>
                                适用场景
                            </h4>
                            <p class="text-gray-700">电商支付场景中：会涉及订单服务、支付服务、库存服务、积分服务、仓储服务等环节，每个服务都是单独部署的。订单服务会调用支付服务生成交易流水，订单服务会调用库存服务扣减商品库存，订单服务会调用积分服务为用户的账户增加积分，订单服务会调用仓储服务生成出库单。如果这一系列的服务调用操作使用强一致性分布式事务，很容易造成系统性能低下，导致系统卡顿，并且服务与服务之问的交互是通过网络进行的，由于网络的不稳定性，就会导致服务之间的调用出现各种各样的问题，难以完成强一致性分布式事务的提交操作。</p>
                        </div>
                        <div>
                            <h4 class="font-bold text-lg mb-3 text-gray-800 flex items-center">
                                <i class="fas fa-balance-scale text-blue-500 mr-2"></i>
                                优缺点
                            </h4>
                            <div class="mb-4">
                                <h5 class="font-bold text-green-600 mb-1">优点：</h5>
                                <ul class="list-disc pl-5 text-gray-700">
                                    <li class="mb-1">性能比较高，这是因为最终一致性分布式事务解决方案不要求数据时刻保持一致不会因长时间持有事务占用的资源而消耗过多的性能</li>
                                    <li class="mb-1">具备可用性</li>
                                    <li>适合高并发场景</li>
                                </ul>
                            </div>
                            <div>
                                <h5 class="font-bold text-red-600 mb-1">缺点：</h5>
                                <ul class="list-disc pl-5 text-gray-700">
                                    <li class="mb-1">因为数据存在短暂的不一致，所以在某个时刻查询出的数据状态可能会不一致</li>
                                    <li>对于事务一致性要求特别高的场景不太适用</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </div>
            </div>

            <!-- 2PC -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-exchange-alt mr-3"></i>
                        2PC (两阶段提交)
                    </h3>
                    <p class="text-gray-700 mb-6">2PC是指有两个阶段，预处理阶段和提交阶段。</p>
                    
                    <div class="grid md:grid-cols-3 gap-6 mb-8">
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">预处理阶段：</h4>
                            <p class="text-gray-700">事务管理器给每个参与全局事务的资源管理器发送Prepare消息，资源管理器要么返回失败，要么在本地执行响应的事务，将事务写入到本地的Redo log和Undo log文件，<strong>此时，事务并没有提交</strong>。</p>
                        </div>
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">提交阶段(成功)：</h4>
                            <p class="text-gray-700">如果事务管理器收到了参与全局事务的资源管理器返回的失败消息，则直接给 Prepare阶段执行成功的资源管理器发送回滚消息，否则，向每个资源管理器发送 Commit 消息。</p>
                        </div>
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">提交阶段(失败)：</h4>
                            <p class="text-gray-700">此时事务协调者收到事务参与者的响应是yes和no，得知其中有一个事务参与者没有超过执行事务。所以要提交回滚的命令给所有的事务的参与者。</p>
                        </div>
                    </div>

                    <div class="grid md:grid-cols-3 gap-6 mb-8">
                        <div class="bg-white border border-gray-200 rounded-lg p-4">
                            <h4 class="font-bold text-center mb-3">预处理阶段</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157178312-32474bd1-c0d4-4e02-89e5-f5898ea3763e.png" alt="预处理阶段" class="w-full rounded">
                        </div>
                        <div class="bg-white border border-gray-200 rounded-lg p-4">
                            <h4 class="font-bold text-center mb-3">提交阶段(成功)</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157197398-fe37cc43-b0d8-4d71-b051-f3a82fcea55e.png" alt="提交阶段成功" class="w-full rounded">
                        </div>
                        <div class="bg-white border border-gray-200 rounded-lg p-4">
                            <h4 class="font-bold text-center mb-3">提交阶段(失败)</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157209497-f30006ca-68d9-446a-8e98-77c735194afc.png" alt="提交阶段失败" class="w-full rounded">
                        </div>
                    </div>

                    <div class="bg-red-50 border-l-4 border-red-400 p-4">
                        <h4 class="font-bold text-lg mb-2 text-red-700">2PC缺点</h4>
                        <ul class="list-disc pl-5 text-red-700">
                            <li class="mb-1">同步阻塞问题：事务的执行过程中，所有参与事务的节点都会对其占用的公共资源加锁，导致其他访问公共资源的进程或者线程阻塞</li>
                            <li class="mb-1">单点故障问题：如果事务管理器发生故障，则资源管理器会一直阻塞</li>
                            <li class="mb-1">数据不一致问题：如果在 Commit 阶段，由于网络或者部分资源管理器发生故障导致部分资源管理器没有接收到事务管理器发送过来的 Commit 消息，会引起数据不一致的问题</li>
                            <li>无法解决的问题：如果在 Commit 阶段，事务管理器发出 Commit 消息后宕机，并且唯一接收到这条Commit 消息的资源管理器也宕机了，则无法确认事务是否已经提交</li>
                        </ul>
                    </div>
                </div>
            </div>

            <!-- 3PC -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-exchange-alt mr-3"></i>
                        3PC (三阶段提交)
                    </h3>
                    <p class="text-gray-700 mb-6">3PC 模型是指三阶段提交模型，是在2PC 模型的基础上改进的版本。3PC模型把 2PC模型中的 Prepare 阶段一分为二，最终形成了个阶段：CanCommit 阶段、PreCommit 阶段和doCommit 或者 doRollback 阶段。3PC 模型的流程同样分为事务执行成功和事务执行失败两种情况。</p>
                    
                    <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157296382-0c1043d1-e94f-4f66-a052-a96ef77b692f.png" alt="3PC模型" class="w-full md:w-2/3 mx-auto rounded-lg mb-8">

                    <div class="grid md:grid-cols-3 gap-6 mb-8">
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">CanCommit阶段</h4>
                            <p class="text-gray-700">协调者向参与者发送CanCommit请求。询问是否可以执行事务提交操作。然后开始等待参与者的响应。参与者接到CanCommit请求之后，正常情况下，如果其自身认为可以顺利执行事务，则返回Yes响应，并进入预备状态。否则反馈No</p>
                        </div>
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">PreCommit阶段</h4>
                            <p class="text-gray-700">在阶段一中，如果所有的参与者都返回Yes的话，那么就会进入PreCommit阶段进行事务预提交。此时分布式事务协调者会向所有的参与者节点发送PreCommit请求，参与者收到后开始执行事务操作，并将Undo和Redo信息记录到事务日志中。</p>
                        </div>
                        <div class="bg-gray-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-gray-800">DoCommit阶段</h4>
                            <p class="text-gray-700">在阶段二中如果所有的参与者节点都可以进行PreCommit提交，那么协调者就会从"预提交状态"->"提交状态"。然后向所有的参与者节点发送"doCommit"请求，参与者节点在收到提交请求后就会各自执行事务提交操作。</p>
                        </div>
                    </div>

                    <div class="bg-blue-50 border-l-4 border-blue-400 p-4">
                        <h4 class="font-bold text-lg mb-2 text-blue-700">3PC存在的问题</h4>
                        <p class="text-blue-700">与2PC 模型相比，3PC 模型主要解决了单点故障问题，并减少了事务执行过程中产生的阻塞现象。在3PC模型中，如果资源管理器无法及时收到来自事务管理器发出的消息那么资源管理器就会执行提交事务的操作，而不是一直持有事务的资源并处于阻塞状态，但是这种机制会导致数据不一致的问题。如果由于网络故障等原因，导致资源管理器没有及时收到事务管理器发出的 Abort消息，则资源管理器会在一段时间后提交事务，这就导致与其他接收到 Abort 消息并执行了事务回滚操作的资源管理器的数据不一致。</p>
                    </div>
                </div>
            </div>

            <!-- TCC -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-red-600 flex items-center">
                        <i class="fas fa-retweet mr-3"></i>
                        TCC (Try-Confirm-Cancel)
                    </h3>
                    <p class="text-gray-700 mb-6">TCC（Try，Confirm，Cancel)和你的业务代码切合在一起。</p>
                    
                    <div class="grid md:grid-cols-3 gap-6 mb-8">
                        <div class="bg-green-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-green-700">Try阶段</h4>
                            <p class="text-gray-700">尝试去预执行具体业务代码。下单订ing... 是做业务检查（一致性）及资源预留（隔离），此阶段仅是一个初步操作，它和后续的Confirm一起才能真正构成一个完整的业务逻辑。</p>
                        </div>
                        <div class="bg-green-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-green-700">Confirm阶段</h4>
                            <p class="text-gray-700">再次执行Confirm的代码。Try阶段所有分支事务执行成功后开始执行Confirm。通常情况下，采用TCC则认为Confirm阶段是不会出错的。即 ：只要Try成功，Confirm一定成功。若Confirm阶段真的出错了，需引入重试机制或人工处理。</p>
                        </div>
                        <div class="bg-green-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-green-700">Cancel阶段</h4>
                            <p class="text-gray-700">再次执行Cancel的代码。是在业务执行错误需要回滚的状态下执行分支事务的业务取消，预留资源释放。通常情况下，采用TCC则认为Cancel阶段也是一定成功的。若Cancel阶段真的出错了，需引入重试机制或人工处理。</p>
                        </div>
                    </div>

                    <div class="grid md:grid-cols-2 gap-6 mb-8">
                        <div class="bg-white border border-gray-200 rounded-lg p-4">
                            <h4 class="font-bold text-center mb-3">TCC成功情况</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157312295-f322401e-b8be-4772-9b33-9b58ca2e7b13.png" alt="TCC成功" class="w-full rounded">
                        </div>
                        <div class="bg-white border border-gray-200 rounded-lg p-4">
                            <h4 class="font-bold text-center mb-3">TCC失败情况</h4>
                            <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157320996-0b4ef79d-49dd-428b-b958-8866ad6a8a5a.png" alt="TCC失败" class="w-full rounded">
                        </div>
                    </div>

                    <div class="bg-white rounded-lg shadow-sm p-6 mb-6">
                        <h4 class="font-bold text-lg mb-4 text-gray-800">使用TCC模式模拟转账业务</h4>
                        <div class="overflow-x-auto">
                            <table class="min-w-full bg-white border border-gray-200">
                                <thead>
                                    <tr class="bg-gray-100">
                                        <th class="py-2 px-4 border"></th>
                                        <th class="py-2 px-4 border">name</th>
                                        <th class="py-2 px-4 border">balance</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    <tr>
                                        <td class="py-2 px-4 border">1</td>
                                        <td class="py-2 px-4 border">A</td>
                                        <td class="py-2 px-4 border">200</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border">2</td>
                                        <td class="py-2 px-4 border">B</td>
                                        <td class="py-2 px-4 border">100</td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>

                    <div class="bg-gray-800 rounded-lg p-6">
                        <pre class="text-green-400 overflow-x-auto"><code>//尝试方法
function try(){
    //记录日志
    todo save A 转出了 100 元 
    todo save B 转入了 100 元 
    //执行转账
    update amount set balacne = balacne-100 where id = 1
    update amount set balacne = balacne+100 where id = 2
}
//确认方法
function confirm(){
    //清理日志
    clean save A 转出了 100 元 
    clean save B 转出了 100 元 
}

//取消方法
function cancle(){
    //加载日志
    load log A
    load log B

     //退钱
    update amount set balacne = balacne+100 where id = 1
    update amount set balacne = balacne-100 where id = 2    
}</code></pre>
                    </div>
                </div>
            </div>
        </section>

        <!-- Database Logs -->
        <section id="logs" class="mb-20">
            <h2 class="text-3xl font-bold mb-6 text-gray-800 flex items-center">
                <i class="fas fa-book mr-4 text-purple-500"></i>
                <span class="highlight">数据库日志文件</span>
            </h2>

            <!-- Undo Log -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-purple-600 flex items-center">
                        <i class="fas fa-undo mr-3"></i>
                        Undo Log
                    </h3>
                    <p class="text-gray-700 mb-6">undo log记录数据被修改前的值，用于事务回滚。<strong>假设修改 tba 表中 id=2的行数据，把Name='B' 修改为Name = 'B2' ，那么undo日志就会用来存放Name='B'的记录，如果这个修改出现异常，可以使用undo日志来实现回滚操作，保证事务的一致性</strong>。</p>
                    <p class="text-gray-700 mb-6">undo log中记录的是当前操作中的相反操作，一条insert语句在undo log中会对应一条delete语句，update语句会在undo log中对应相反的update语句，在事务回滚时会用到undo log，实现事务的原子性。</p>
                    
                    <div class="bg-gray-800 rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto"><code>-- undo log记录
update t1 set name = "B" where id = 1
-- 执行语句
update t1 set name = 'B2' where id = 1

-- undo log记录
delete t1 where name = 'B3'
-- 执行语句
insert into t1(name) values('B3')</code></pre>
                    </div>
                </div>
            </div>

            <!-- Redo Log -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-purple-600 flex items-center">
                        <i class="fas fa-redo mr-3"></i>
                        Redo Log
                    </h3>
                    <p class="text-gray-700 mb-6">redo log记录修改后的数据，用于提交事务后写入数据文件，DB宕机后方便数据恢复</p>
                    <p class="text-gray-700 mb-6">redo log是当数据库对数据做修改的时候，需要把数据页从磁盘读到buffer pool中，然后在buffer pool中进行修改，那么这个时候buffer pool中的数据页就与磁盘上的数据页内容不一致，如果这个时候发生非正常的DB服务重启，数据并没有同步到磁盘文件中，也就是会发生数据丢失，如果这个时候，能够在有一个文件，当buffer pool 中的data page变更结束后，把相应修改记录记录到这个文件，那么当DB服务发生宕机的情况，恢复DB的时候，也可以根据这个文件的记录内容，重新应用到磁盘文件，数据保持一致。</p>
                    <p class="text-gray-700 mb-6">redo log中记录的是要更新的数据，比如一条数据已提交成功，并不会立即同步到磁盘，而是先记录到redo log中，等待合适的时机再刷盘，为了实现事务的持久性。</p>
                    
                    <div class="bg-yellow-50 border-l-4 border-yellow-400 p-4">
                        <h4 class="font-bold text-lg mb-2 text-yellow-700">什么是Buffer Pool?</h4>
                        <p class="text-yellow-700">应用系统分层架构，为了加速数据访问，会把最常访问的数据，放在<strong>缓存</strong>(cache)里，避免每次都去访问数据库。<br>操作系统，会有<strong>缓冲池</strong>(buffer pool)机制，避免每次访问磁盘，以加速数据的访问。<br>MySQL作为一个存储系统，同样具有<strong>缓冲池</strong>(buffer pool)机制，以避免每次查询数据都进行磁盘IO。</p>
                        <p class="text-yellow-700 mt-2"><strong>缓冲池(buffer pool)</strong>是一种常见的降低磁盘访问的机制，缓冲池通常以页(page)为单位缓存数据；</p>
                    </div>
                </div>
            </div>

            <!-- Bin Log -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden mb-10 card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-purple-600 flex items-center">
                        <i class="fas fa-database mr-3"></i>
                        Bin Log
                    </h3>
                    <p class="text-gray-700 mb-6">bin log中记录的是整个mysql数据库的操作内容，对所有的引擎都适用，包括执行的DDL、DML，可以用来进行数据库的恢复及复制，bin log有三种形式：statement、row、mixed。</p>
                    <p class="text-gray-700 mb-6"><strong>statement</strong>是记录执行的sql语句，该种形式的文件比较小，例，update t1 set age='24' where name like '%王%'，这样一条语句，在statement下就会记录这样一条sql。</p>
                    <p class="text-gray-700 mb-6"><strong>row</strong>是基于数据行的，会记录变化的所有数据，一般文件较大。例，update t1 set age='24' where name like '%王%'，这条语句，在row的形式下，则会记录该条sql影响的所有数据记录；</p>
                    <p class="text-gray-700"><strong>mixed</strong>是混合格式，是statement和row的组合。</p>
                </div>
            </div>

            <!-- Log Functions -->
            <div class="bg-white rounded-xl shadow-md overflow-hidden card-hover">
                <div class="p-8">
                    <h3 class="text-2xl font-bold mb-6 text-purple-600 flex items-center">
                        <i class="fas fa-tasks mr-3"></i>
                        三种日志作用
                    </h3>
                    <div class="grid md:grid-cols-3 gap-6">
                        <div class="bg-purple-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-purple-700">回滚日志（undo log）</h4>
                            <p class="text-gray-700">保存了事务发生之前的数据的一个版本，可以用于回滚。</p>
                        </div>
                        <div class="bg-purple-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-purple-700">重做日志（redo log）</h4>
                            <p class="text-gray-700">确保事务的持久性。防止在发生故障的时间点，尚有脏页未写入磁盘，在重启mysql服务的时候，根据redo log进行重做，从而达到事务的持久性这一特性。</p>
                        </div>
                        <div class="bg-purple-50 p-5 rounded-lg">
                            <h4 class="font-bold text-lg mb-2 text-purple-700">二进制日志（binlog）</h4>
                            <p class="text-gray-700">用于复制，在主从复制中，从库利用主库上的binlog进行重播，实现主从同步。<br>用于数据库的基于时间点的还原。</p>
                        </div>
                    </div>
                    
                    <div class="mt-10">
                        <h4 class="text-2xl font-bold mb-6 text-gray-800">日志写入顺序</h4>
                        <img src="https://cdn.nlark.com/yuque/0/2022/png/21449790/1651157410499-82e1f5c3-6d29-4927-8cd7-2e671e2920e9.png" alt="日志写入顺序" class="w-full md:w-2/3 mx-auto rounded-lg">
                    </div>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-white py-12">
        <div class="container mx-auto max-w-6xl px-4">
            <div class="flex flex-col items-center">
                <h3 class="text-2xl font-bold mb-4">技术小馆</h3>
                <a href="http://www.yuque.com/jtostring" class="text-gray-300 hover:text-white transition">http://www.yuque.com/jtostring</a>
                <div class="mt-6 flex space-x-6">
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-github fa-lg"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-twitter fa-lg"></i></a>
                    <a href="#" class="text-gray-400 hover:text-white transition"><i class="fab fa-weixin fa-lg"></i></a>
                </div>
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```